// 导入订单服务模块，封装订单相关业务逻辑
const orderService = require("../services/orderService");

/**
 * 获取所有订单（支持分页、多条件筛选）
 * @param {Object} req - 请求对象：query参数含分页（page/limit）、筛选（userId/status/paymentStatus/startTime/endTime）
 * @param {Object} res - 响应对象
 * @param {Function} next - 错误传递中间件
 */
exports.getAllOrders = async (req, res, next) => {
  try {
    // 提取分页参数（默认第1页，每页10条）
    const page = req.query.page || 1;
    const limit = req.query.limit || 10;

    // 构建筛选条件：用户ID、订单状态、支付状态、时间范围
    const filters = {
      userId: req.query.userId, // 按用户筛选
      status: req.query.status, // 订单状态（pending/confirmed/...）
      paymentStatus: req.query.paymentStatus, // 支付状态（pending/paid/...）
      startTime: req.query.startTime, // 下单开始时间（YYYY-MM-DD）
      endTime: req.query.endTime, // 下单结束时间（YYYY-MM-DD）
    };

    // 调用服务层获取订单列表（联表用户信息）
    const result = await orderService.findAllOrders(page, limit, filters);

    // 返回统一格式响应
    res.json({
      code: 200,
      msg: "成功",
      data: result.orders, // 订单列表（含关联用户信息）
      pagination: result.pagination, // 分页信息（总条数/总页数）
    });
  } catch (error) {
    next(error);
  }
};

/**
 * 获取单个订单详情（联表用户+订单项+产品）
 * @param {Object} req - 请求对象：params.id 为订单ID
 * @param {Object} res - 响应对象
 * @param {Function} next - 错误传递中间件
 */
exports.getOrderById = async (req, res, next) => {
  try {
    // 调用服务层获取订单详情（联表用户、订单项、产品）
    const order = await orderService.findOrderById(req.params.id);

    res.json({
      code: 200,
      msg: "成功",
      data: order, // 订单详情（含用户、订单项+产品）
    });
  } catch (error) {
    next(error);
  }
};

/**
 * 创建新订单（含订单项）
 * @param {Object} req - 请求体：userId、paymentMethod、shippingAddress、items（订单项数组）
 * @param {Object} res - 响应对象
 * @param {Function} next - 错误传递中间件
 */
exports.createOrder = async (req, res, next) => {
  try {
    // 调用服务层创建订单（事务处理：订单+订单项）
    const order = await orderService.createOrder(req.body);

    // 201 状态码表示资源创建成功
    res.status(201).json({
      code: 201,
      msg: "订单创建成功",
      data: order, // 返回创建的订单（含订单项）
    });
  } catch (error) {
    next(error);
  }
};

/**
 * 更新订单信息
 * @param {Object} req - 请求对象：params.id（订单ID），body（待更新字段）
 * @param {Object} res - 响应对象
 * @param {Function} next - 错误传递中间件
 */
exports.updateOrder = async (req, res, next) => {
  try {
    // 调用服务层更新订单（限制可更新字段）
    const order = await orderService.updateOrder(req.params.id, req.body);

    res.json({
      code: 200,
      msg: "订单更新成功",
      data: order, // 返回更新后的订单
    });
  } catch (error) {
    next(error);
  }
};

/**
 * 删除订单（级联删除订单项）
 * @param {Object} req - 请求对象：params.id 为订单ID
 * @param {Object} res - 响应对象
 * @param {Function} next - 错误传递中间件
 */
exports.deleteOrder = async (req, res, next) => {
  try {
    // 调用服务层删除订单（事务处理：订单+订单项）
    const result = await orderService.deleteOrder(req.params.id);

    res.json({
      code: 200,
      msg: result.message,
    });
  } catch (error) {
    next(error);
  }
};

/**
 * 根据用户ID查询订单数量
 * @param {Object} req - 请求参数：params.userId为用户ID
 * @param {Object} res - 响应对象
 * @param {Function} next - 错误处理中间件
 */
exports.getUserOrderCount = async (req, res, next) => {
  try {
    const userId = req.params.userId;

    // 验证用户ID是否有效
    if (!userId || isNaN(Number(userId))) {
      throw createError(400, "无效的用户ID（必须是数字）");
    }

    // 调用服务层查询订单数量
    const count = await orderService.getUserOrderCount(Number(userId));

    res.json({
      code: 200,
      msg: "查询成功",
      data: {
        userId: Number(userId),
        orderCount: count, // 订单数量
      },
    });
  } catch (error) {
    next(error);
  }
};
